<?php
    /** PHPExcel root directory */
    if (!defined('PHPEXCEL_ROOT')) {
        /**
         * @ignore
         */
        define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
        require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
    }

    /**
     * PHPExcel_Calculation_DateTime
     * Copyright (c) 2006 - 2015 PHPExcel
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Lesser General Public
     * License as published by the Free Software Foundation; either
     * version 2.1 of the License, or (at your option) any later version.
     * This library is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
     * Lesser General Public License for more details.
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
     * @category       PHPExcel
     * @package        PHPExcel_Calculation
     * @copyright      Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
     * @license        http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
     * @version        ##VERSION##, ##DATE##
     */
    class PHPExcel_Calculation_DateTime {
        /**
         * DATETIMENOW
         * Returns the current date and time.
         * The NOW function is useful when you need to display the current date and time on a worksheet or
         * calculate a value based on the current date and time, and have that value updated each time you
         * open the worksheet.
         * NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
         * and time format of your regional settings. PHPExcel does not change cell formatting in this way.
         * Excel Function:
         *        NOW()
         * @access    public
         * @category  Date/Time Functions
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                        depending on the value of the ReturnDateType flag
         */
        public static function DATETIMENOW() {
            $saveTimeZone = date_default_timezone_get();
            date_default_timezone_set('UTC');
            $retValue = false;
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    $retValue = (float)PHPExcel_Shared_Date::PHPToExcel(time());
                    break;
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    $retValue = (integer)time();
                    break;
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    $retValue = new DateTime();
                    break;
            }
            date_default_timezone_set($saveTimeZone);
            return $retValue;
        }

        /**
         * DATENOW
         * Returns the current date.
         * The NOW function is useful when you need to display the current date and time on a worksheet or
         * calculate a value based on the current date and time, and have that value updated each time you
         * open the worksheet.
         * NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
         * and time format of your regional settings. PHPExcel does not change cell formatting in this way.
         * Excel Function:
         *        TODAY()
         * @access    public
         * @category  Date/Time Functions
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                        depending on the value of the ReturnDateType flag
         */
        public static function DATENOW() {
            $saveTimeZone = date_default_timezone_get();
            date_default_timezone_set('UTC');
            $retValue      = false;
            $excelDateTime = floor(PHPExcel_Shared_Date::PHPToExcel(time()));
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    $retValue = (float)$excelDateTime;
                    break;
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    $retValue = (integer)PHPExcel_Shared_Date::ExcelToPHP($excelDateTime);
                    break;
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    $retValue = PHPExcel_Shared_Date::ExcelToPHPObject($excelDateTime);
                    break;
            }
            date_default_timezone_set($saveTimeZone);
            return $retValue;
        }

        /**
         * DATE
         * The DATE function returns a value that represents a particular date.
         * NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
         * format of your regional settings. PHPExcel does not change cell formatting in this way.
         * Excel Function:
         *        DATE(year,month,day)
         * PHPExcel is a lot more forgiving than MS Excel when passing non numeric values to this function.
         * A Month name or abbreviation (English only at this point) such as 'January' or 'Jan' will still be accepted,
         *     as will a day value with a suffix (e.g. '21st' rather than simply 21); again only English language.
         * @access    public
         * @category  Date/Time Functions
         * @param    integer $year        The value of the year argument can include one to four digits.
         *                                Excel interprets the year argument according to the configured
         *                                date system: 1900 or 1904.
         *                                If year is between 0 (zero) and 1899 (inclusive), Excel adds that
         *                                value to 1900 to calculate the year. For example, DATE(108,1,2)
         *                                returns January 2, 2008 (1900+108).
         *                                If year is between 1900 and 9999 (inclusive), Excel uses that
         *                                value as the year. For example, DATE(2008,1,2) returns January 2,
         *                                2008.
         *                                If year is less than 0 or is 10000 or greater, Excel returns the
         *                                #NUM! error value.
         * @param    integer $month       A positive or negative integer representing the month of the year
         *                                from 1 to 12 (January to December).
         *                                If month is greater than 12, month adds that number of months to
         *                                the first month in the year specified. For example, DATE(2008,14,2)
         *                                returns the serial number representing February 2, 2009.
         *                                If month is less than 1, month subtracts the magnitude of that
         *                                number of months, plus 1, from the first month in the year
         *                                specified. For example, DATE(2008,-3,2) returns the serial number
         *                                representing September 2, 2007.
         * @param    integer $day         A positive or negative integer representing the day of the month
         *                                from 1 to 31.
         *                                If day is greater than the number of days in the month specified,
         *                                day adds that number of days to the first day in the month. For
         *                                example, DATE(2008,1,35) returns the serial number representing
         *                                February 4, 2008.
         *                                If day is less than 1, day subtracts the magnitude that number of
         *                                days, plus one, from the first day of the month specified. For
         *                                example, DATE(2008,1,-15) returns the serial number representing
         *                                December 16, 2007.
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                depending on the value of the ReturnDateType flag
         */
        public static function DATE($year = 0, $month = 1, $day = 1) {
            $year  = PHPExcel_Calculation_Functions::flattenSingleValue($year);
            $month = PHPExcel_Calculation_Functions::flattenSingleValue($month);
            $day   = PHPExcel_Calculation_Functions::flattenSingleValue($day);
            if (($month !== null) && (!is_numeric($month))) {
                $month = PHPExcel_Shared_Date::monthStringToNumber($month);
            }
            if (($day !== null) && (!is_numeric($day))) {
                $day = PHPExcel_Shared_Date::dayStringToNumber($day);
            }
            $year  = ($year !== null) ? PHPExcel_Shared_String::testStringAsNumeric($year) : 0;
            $month = ($month !== null) ? PHPExcel_Shared_String::testStringAsNumeric($month) : 0;
            $day   = ($day !== null) ? PHPExcel_Shared_String::testStringAsNumeric($day) : 0;
            if ((!is_numeric($year)) || (!is_numeric($month)) || (!is_numeric($day))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $year  = (integer)$year;
            $month = (integer)$month;
            $day   = (integer)$day;
            $baseYear = PHPExcel_Shared_Date::getExcelCalendar();
            // Validate parameters
            if ($year < ($baseYear - 1900)) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            if ((($baseYear - 1900) != 0) && ($year < $baseYear) && ($year >= 1900)) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            if (($year < $baseYear) && ($year >= ($baseYear - 1900))) {
                $year += 1900;
            }
            if ($month < 1) {
                //    Handle year/month adjustment if month < 1
                --$month;
                $year  += ceil($month / 12) - 1;
                $month = 13 - abs($month % 12);
            } elseif ($month > 12) {
                //    Handle year/month adjustment if month > 12
                $year  += floor($month / 12);
                $month = ($month % 12);
            }
            // Re-validate the year parameter after adjustments
            if (($year < $baseYear) || ($year >= 10000)) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($year, $month, $day);
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    return (float)$excelDateValue;
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    return (integer)PHPExcel_Shared_Date::ExcelToPHP($excelDateValue);
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    return PHPExcel_Shared_Date::ExcelToPHPObject($excelDateValue);
            }
        }

        /**
         * TIME
         * The TIME function returns a value that represents a particular time.
         * NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the time
         * format of your regional settings. PHPExcel does not change cell formatting in this way.
         * Excel Function:
         *        TIME(hour,minute,second)
         * @access    public
         * @category  Date/Time Functions
         * @param    integer $hour            A number from 0 (zero) to 32767 representing the hour.
         *                                    Any value greater than 23 will be divided by 24 and the remainder
         *                                    will be treated as the hour value. For example, TIME(27,0,0) =
         *                                    TIME(3,0,0) = .125 or 3:00 AM.
         * @param    integer $minute          A number from 0 to 32767 representing the minute.
         *                                    Any value greater than 59 will be converted to hours and minutes.
         *                                    For example, TIME(0,750,0) = TIME(12,30,0) = .520833 or 12:30 PM.
         * @param    integer $second          A number from 0 to 32767 representing the second.
         *                                    Any value greater than 59 will be converted to hours, minutes,
         *                                    and seconds. For example, TIME(0,0,2000) = TIME(0,33,22) = .023148
         *                                    or 12:33:20 AM
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                    depending on the value of the ReturnDateType flag
         */
        public static function TIME($hour = 0, $minute = 0, $second = 0) {
            $hour   = PHPExcel_Calculation_Functions::flattenSingleValue($hour);
            $minute = PHPExcel_Calculation_Functions::flattenSingleValue($minute);
            $second = PHPExcel_Calculation_Functions::flattenSingleValue($second);
            if ($hour == '') {
                $hour = 0;
            }
            if ($minute == '') {
                $minute = 0;
            }
            if ($second == '') {
                $second = 0;
            }
            if ((!is_numeric($hour)) || (!is_numeric($minute)) || (!is_numeric($second))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $hour   = (integer)$hour;
            $minute = (integer)$minute;
            $second = (integer)$second;
            if ($second < 0) {
                $minute += floor($second / 60);
                $second = 60 - abs($second % 60);
                if ($second == 60) {
                    $second = 0;
                }
            } elseif ($second >= 60) {
                $minute += floor($second / 60);
                $second = $second % 60;
            }
            if ($minute < 0) {
                $hour   += floor($minute / 60);
                $minute = 60 - abs($minute % 60);
                if ($minute == 60) {
                    $minute = 0;
                }
            } elseif ($minute >= 60) {
                $hour   += floor($minute / 60);
                $minute = $minute % 60;
            }
            if ($hour > 23) {
                $hour = $hour % 24;
            } elseif ($hour < 0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    $date     = 0;
                    $calendar = PHPExcel_Shared_Date::getExcelCalendar();
                    if ($calendar != PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900) {
                        $date = 1;
                    }
                    return (float)PHPExcel_Shared_Date::FormattedPHPToExcel($calendar, 1, $date, $hour, $minute, $second);
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    return (integer)PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::FormattedPHPToExcel(1970, 1, 1, $hour, $minute, $second));    // -2147468400; //    -2147472000 + 3600
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    $dayAdjust = 0;
                    if ($hour < 0) {
                        $dayAdjust = floor($hour / 24);
                        $hour      = 24 - abs($hour % 24);
                        if ($hour == 24) {
                            $hour = 0;
                        }
                    } elseif ($hour >= 24) {
                        $dayAdjust = floor($hour / 24);
                        $hour      = $hour % 24;
                    }
                    $phpDateObject = new DateTime('1900-01-01 ' . $hour . ':' . $minute . ':' . $second);
                    if ($dayAdjust != 0) {
                        $phpDateObject->modify($dayAdjust . ' days');
                    }
                    return $phpDateObject;
            }
        }

        /**
         * YEARFRAC
         * Calculates the fraction of the year represented by the number of whole days between two dates
         * (the start_date and the end_date).
         * Use the YEARFRAC worksheet function to identify the proportion of a whole year's benefits or
         * obligations to assign to a specific term.
         * Excel Function:
         *        YEARFRAC(startDate,endDate[,method])
         * @access    public
         * @category  Date/Time Functions
         * @param    mixed   $startDate           Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    mixed   $endDate             Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    integer $method              Method used for the calculation
         *                                        0 or omitted    US (NASD) 30/360
         *                                        1                Actual/actual
         *                                        2                Actual/360
         *                                        3                Actual/365
         *                                        4                European 30/360
         * @return    float    fraction of the year
         */
        public static function YEARFRAC($startDate = 0, $endDate = 0, $method = 0) {
            $startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
            $endDate   = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
            $method    = PHPExcel_Calculation_Functions::flattenSingleValue($method);
            if (is_string($startDate = self::getDateValue($startDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            if (is_string($endDate = self::getDateValue($endDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            if (((is_numeric($method)) && (!is_string($method))) || ($method == '')) {
                switch ($method) {
                    case 0:
                        return self::DAYS360($startDate, $endDate) / 360;
                    case 1:
                        $days      = self::DATEDIF($startDate, $endDate);
                        $startYear = self::YEAR($startDate);
                        $endYear   = self::YEAR($endDate);
                        $years     = $endYear - $startYear + 1;
                        $leapDays  = 0;
                        if ($years == 1) {
                            if (self::isLeapYear($endYear)) {
                                $startMonth = self::MONTHOFYEAR($startDate);
                                $endMonth   = self::MONTHOFYEAR($endDate);
                                $endDay     = self::DAYOFMONTH($endDate);
                                if (($startMonth < 3) || (($endMonth * 100 + $endDay) >= (2 * 100 + 29))) {
                                    $leapDays += 1;
                                }
                            }
                        } else {
                            for ($year = $startYear; $year <= $endYear; ++$year) {
                                if ($year == $startYear) {
                                    $startMonth = self::MONTHOFYEAR($startDate);
                                    $startDay   = self::DAYOFMONTH($startDate);
                                    if ($startMonth < 3) {
                                        $leapDays += (self::isLeapYear($year)) ? 1 : 0;
                                    }
                                } elseif ($year == $endYear) {
                                    $endMonth = self::MONTHOFYEAR($endDate);
                                    $endDay   = self::DAYOFMONTH($endDate);
                                    if (($endMonth * 100 + $endDay) >= (2 * 100 + 29)) {
                                        $leapDays += (self::isLeapYear($year)) ? 1 : 0;
                                    }
                                } else {
                                    $leapDays += (self::isLeapYear($year)) ? 1 : 0;
                                }
                            }
                            if ($years == 2) {
                                if (($leapDays == 0) && (self::isLeapYear($startYear)) && ($days > 365)) {
                                    $leapDays = 1;
                                } elseif ($days < 366) {
                                    $years = 1;
                                }
                            }
                            $leapDays /= $years;
                        }
                        return $days / (365 + $leapDays);
                    case 2:
                        return self::DATEDIF($startDate, $endDate) / 360;
                    case 3:
                        return self::DATEDIF($startDate, $endDate) / 365;
                    case 4:
                        return self::DAYS360($startDate, $endDate, true) / 360;
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * getDateValue
         * @param    string $dateValue
         * @return    mixed    Excel date/time serial value, or string if error
         */
        public static function getDateValue($dateValue) {
            if (!is_numeric($dateValue)) {
                if ((is_string($dateValue)) && (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC)) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                if ((is_object($dateValue)) && ($dateValue instanceof DateTime)) {
                    $dateValue = PHPExcel_Shared_Date::PHPToExcel($dateValue);
                } else {
                    $saveReturnDateType = PHPExcel_Calculation_Functions::getReturnDateType();
                    PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
                    $dateValue = self::DATEVALUE($dateValue);
                    PHPExcel_Calculation_Functions::setReturnDateType($saveReturnDateType);
                }
            }
            return $dateValue;
        }

        /**
         * DATEVALUE
         * Returns a value that represents a particular date.
         * Use DATEVALUE to convert a date represented by a text string to an Excel or PHP date/time stamp
         * value.
         * NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the date
         * format of your regional settings. PHPExcel does not change cell formatting in this way.
         * Excel Function:
         *        DATEVALUE(dateValue)
         * @access    public
         * @category  Date/Time Functions
         * @param    string $dateValue        Text that represents a date in a Microsoft Excel date format.
         *                                    For example, "1/30/2008" or "30-Jan-2008" are text strings within
         *                                    quotation marks that represent dates. Using the default date
         *                                    system in Excel for Windows, date_text must represent a date from
         *                                    January 1, 1900, to December 31, 9999. Using the default date
         *                                    system in Excel for the Macintosh, date_text must represent a date
         *                                    from January 1, 1904, to December 31, 9999. DATEVALUE returns the
         *                                    #VALUE! error value if date_text is out of this range.
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                    depending on the value of the ReturnDateType flag
         */
        public static function DATEVALUE($dateValue = 1) {
            $dateValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($dateValue), '"');
            //    Strip any ordinals because they're allowed in Excel (English only)
            $dateValue = preg_replace('/(\d)(st|nd|rd|th)([ -\/])/Ui', '$1$3', $dateValue);
            //    Convert separators (/ . or space) to hyphens (should also handle dot used for ordinals in some countries, e.g. Denmark, Germany)
            $dateValue = str_replace([
                                         '/',
                                         '.',
                                         '-',
                                         '  '
                                     ], [
                                         ' ',
                                         ' ',
                                         ' ',
                                         ' '
                                     ], $dateValue
            );
            $yearFound = false;
            $t1        = explode(' ', $dateValue);
            foreach ($t1 as &$t) {
                if ((is_numeric($t)) && ($t > 31)) {
                    if ($yearFound) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    } else {
                        if ($t < 100) {
                            $t += 1900;
                        }
                        $yearFound = true;
                    }
                }
            }
            if ((count($t1) == 1) && (strpos($t, ':') != false)) {
                //    We've been fed a time value without any date
                return 0.0;
            } elseif (count($t1) == 2) {
                //    We only have two parts of the date: either day/month or month/year
                if ($yearFound) {
                    array_unshift($t1, 1);
                } else {
                    array_push($t1, date('Y'));
                }
            }
            unset($t);
            $dateValue = implode(' ', $t1);
            $PHPDateArray = date_parse($dateValue);
            if (($PHPDateArray === false) || ($PHPDateArray['error_count'] > 0)) {
                $testVal1 = strtok($dateValue, '- ');
                if ($testVal1 !== false) {
                    $testVal2 = strtok('- ');
                    if ($testVal2 !== false) {
                        $testVal3 = strtok('- ');
                        if ($testVal3 === false) {
                            $testVal3 = strftime('%Y');
                        }
                    } else {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                } else {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                $PHPDateArray = date_parse($testVal1 . '-' . $testVal2 . '-' . $testVal3);
                if (($PHPDateArray === false) || ($PHPDateArray['error_count'] > 0)) {
                    $PHPDateArray = date_parse($testVal2 . '-' . $testVal1 . '-' . $testVal3);
                    if (($PHPDateArray === false) || ($PHPDateArray['error_count'] > 0)) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                }
            }
            if (($PHPDateArray !== false) && ($PHPDateArray['error_count'] == 0)) {
                // Execute function
                if ($PHPDateArray['year'] == '') {
                    $PHPDateArray['year'] = strftime('%Y');
                }
                if ($PHPDateArray['year'] < 1900) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                if ($PHPDateArray['month'] == '') {
                    $PHPDateArray['month'] = strftime('%m');
                }
                if ($PHPDateArray['day'] == '') {
                    $PHPDateArray['day'] = strftime('%d');
                }
                $excelDateValue = floor(PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'], $PHPDateArray['month'], $PHPDateArray['day'], $PHPDateArray['hour'], $PHPDateArray['minute'], $PHPDateArray['second']
                )
                );
                switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                    case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                        return (float)$excelDateValue;
                    case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                        return (integer)PHPExcel_Shared_Date::ExcelToPHP($excelDateValue);
                    case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                        return new DateTime($PHPDateArray['year'] . '-' . $PHPDateArray['month'] . '-' . $PHPDateArray['day'] . ' 00:00:00');
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * DAYS360
         * Returns the number of days between two dates based on a 360-day year (twelve 30-day months),
         * which is used in some accounting calculations. Use this function to help compute payments if
         * your accounting system is based on twelve 30-day months.
         * Excel Function:
         *        DAYS360(startDate,endDate[,method])
         * @access    public
         * @category  Date/Time Functions
         * @param    mixed   $startDate           Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    mixed   $endDate             Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    boolean $method              US or European Method
         *                                        FALSE or omitted: U.S. (NASD) method. If the starting date is
         *                                        the last day of a month, it becomes equal to the 30th of the
         *                                        same month. If the ending date is the last day of a month and
         *                                        the starting date is earlier than the 30th of a month, the
         *                                        ending date becomes equal to the 1st of the next month;
         *                                        otherwise the ending date becomes equal to the 30th of the
         *                                        same month.
         *                                        TRUE: European method. Starting dates and ending dates that
         *                                        occur on the 31st of a month become equal to the 30th of the
         *                                        same month.
         * @return    integer        Number of days between start date and end date
         */
        public static function DAYS360($startDate = 0, $endDate = 0, $method = false) {
            $startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
            $endDate   = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
            if (is_string($startDate = self::getDateValue($startDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            if (is_string($endDate = self::getDateValue($endDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            if (!is_bool($method)) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            // Execute function
            $PHPStartDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($startDate);
            $startDay           = $PHPStartDateObject->format('j');
            $startMonth         = $PHPStartDateObject->format('n');
            $startYear          = $PHPStartDateObject->format('Y');
            $PHPEndDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
            $endDay           = $PHPEndDateObject->format('j');
            $endMonth         = $PHPEndDateObject->format('n');
            $endYear          = $PHPEndDateObject->format('Y');
            return self::dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, !$method);
        }

        /**
         * Return the number of days between two dates based on a 360 day calendar
         * @param    integer $startDay   Day of month of the start date
         * @param    integer $startMonth Month of the start date
         * @param    integer $startYear  Year of the start date
         * @param    integer $endDay     Day of month of the start date
         * @param    integer $endMonth   Month of the start date
         * @param    integer $endYear    Year of the start date
         * @param    boolean $methodUS   Whether to use the US method or the European method of calculation
         * @return    integer    Number of days between the start date and the end date
         */
        private static function dateDiff360($startDay, $startMonth, $startYear, $endDay, $endMonth, $endYear, $methodUS) {
            if ($startDay == 31) {
                --$startDay;
            } elseif ($methodUS && ($startMonth == 2 && ($startDay == 29 || ($startDay == 28 && !self::isLeapYear($startYear))))) {
                $startDay = 30;
            }
            if ($endDay == 31) {
                if ($methodUS && $startDay != 30) {
                    $endDay = 1;
                    if ($endMonth == 12) {
                        ++$endYear;
                        $endMonth = 1;
                    } else {
                        ++$endMonth;
                    }
                } else {
                    $endDay = 30;
                }
            }
            return $endDay + $endMonth * 30 + $endYear * 360 - $startDay - $startMonth * 30 - $startYear * 360;
        }

        /**
         * Identify if a year is a leap year or not
         * @param    integer $year The year to test
         * @return    boolean            TRUE if the year is a leap year, otherwise FALSE
         */
        public static function isLeapYear($year) {
            return ((($year % 4) == 0) && (($year % 100) != 0) || (($year % 400) == 0));
        }

        /**
         * DATEDIF
         * @param    mixed  $startDate        Excel date serial value, PHP date/time stamp, PHP DateTime object
         *                                    or a standard date string
         * @param    mixed  $endDate          Excel date serial value, PHP date/time stamp, PHP DateTime object
         *                                    or a standard date string
         * @param    string $unit
         * @return    integer    Interval between the dates
         */
        public static function DATEDIF($startDate = 0, $endDate = 0, $unit = 'D') {
            $startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
            $endDate   = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
            $unit      = strtoupper(PHPExcel_Calculation_Functions::flattenSingleValue($unit));
            if (is_string($startDate = self::getDateValue($startDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            if (is_string($endDate = self::getDateValue($endDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            // Validate parameters
            if ($startDate >= $endDate) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $difference = $endDate - $startDate;
            $PHPStartDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($startDate);
            $startDays          = $PHPStartDateObject->format('j');
            $startMonths        = $PHPStartDateObject->format('n');
            $startYears         = $PHPStartDateObject->format('Y');
            $PHPEndDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
            $endDays          = $PHPEndDateObject->format('j');
            $endMonths        = $PHPEndDateObject->format('n');
            $endYears         = $PHPEndDateObject->format('Y');
            $retVal = PHPExcel_Calculation_Functions::NaN();
            switch ($unit) {
                case 'D':
                    $retVal = intval($difference);
                    break;
                case 'M':
                    $retVal = intval($endMonths - $startMonths) + (intval($endYears - $startYears) * 12);
                    //    We're only interested in full months
                    if ($endDays < $startDays) {
                        --$retVal;
                    }
                    break;
                case 'Y':
                    $retVal = intval($endYears - $startYears);
                    //    We're only interested in full months
                    if ($endMonths < $startMonths) {
                        --$retVal;
                    } elseif (($endMonths == $startMonths) && ($endDays < $startDays)) {
                        --$retVal;
                    }
                    break;
                case 'MD':
                    if ($endDays < $startDays) {
                        $retVal = $endDays;
                        $PHPEndDateObject->modify('-' . $endDays . ' days');
                        $adjustDays = $PHPEndDateObject->format('j');
                        if ($adjustDays > $startDays) {
                            $retVal += ($adjustDays - $startDays);
                        }
                    } else {
                        $retVal = $endDays - $startDays;
                    }
                    break;
                case 'YM':
                    $retVal = intval($endMonths - $startMonths);
                    if ($retVal < 0) {
                        $retVal += 12;
                    }
                    //    We're only interested in full months
                    if ($endDays < $startDays) {
                        --$retVal;
                    }
                    break;
                case 'YD':
                    $retVal = intval($difference);
                    if ($endYears > $startYears) {
                        while ($endYears > $startYears) {
                            $PHPEndDateObject->modify('-1 year');
                            $endYears = $PHPEndDateObject->format('Y');
                        }
                        $retVal = $PHPEndDateObject->format('z') - $PHPStartDateObject->format('z');
                        if ($retVal < 0) {
                            $retVal += 365;
                        }
                    }
                    break;
                default:
                    $retVal = PHPExcel_Calculation_Functions::NaN();
            }
            return $retVal;
        }

        /**
         * YEAR
         * Returns the year corresponding to a date.
         * The year is returned as an integer in the range 1900-9999.
         * Excel Function:
         *        YEAR(dateValue)
         * @param    mixed $dateValue         Excel date serial value (float), PHP date timestamp (integer),
         *                                    PHP DateTime object, or a standard date string
         * @return    int        Year
         */
        public static function YEAR($dateValue = 1) {
            $dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            if ($dateValue === null) {
                $dateValue = 1;
            } elseif (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif ($dateValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
            return (int)$PHPDateObject->format('Y');
        }

        /**
         * MONTHOFYEAR
         * Returns the month of a date represented by a serial number.
         * The month is given as an integer, ranging from 1 (January) to 12 (December).
         * Excel Function:
         *        MONTH(dateValue)
         * @param    mixed $dateValue         Excel date serial value (float), PHP date timestamp (integer),
         *                                    PHP DateTime object, or a standard date string
         * @return    int        Month of the year
         */
        public static function MONTHOFYEAR($dateValue = 1) {
            $dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            if ($dateValue === null) {
                $dateValue = 1;
            } elseif (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif ($dateValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
            return (int)$PHPDateObject->format('n');
        }

        /**
         * DAYOFMONTH
         * Returns the day of the month, for a specified date. The day is given as an integer
         * ranging from 1 to 31.
         * Excel Function:
         *        DAY(dateValue)
         * @param    mixed $dateValue         Excel date serial value (float), PHP date timestamp (integer),
         *                                    PHP DateTime object, or a standard date string
         * @return    int        Day of the month
         */
        public static function DAYOFMONTH($dateValue = 1) {
            $dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            if ($dateValue === null) {
                $dateValue = 1;
            } elseif (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif ($dateValue == 0.0) {
                return 0;
            } elseif ($dateValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
            return (int)$PHPDateObject->format('j');
        }

        /**
         * NETWORKDAYS
         * Returns the number of whole working days between start_date and end_date. Working days
         * exclude weekends and any dates identified in holidays.
         * Use NETWORKDAYS to calculate employee benefits that accrue based on the number of days
         * worked during a specific term.
         * Excel Function:
         *        NETWORKDAYS(startDate,endDate[,holidays[,holiday[,...]]])
         * @access    public
         * @category  Date/Time Functions
         * @param    mixed $startDate                 Excel date serial value (float), PHP date timestamp (integer),
         *                                            PHP DateTime object, or a standard date string
         * @param    mixed $endDate                   Excel date serial value (float), PHP date timestamp (integer),
         *                                            PHP DateTime object, or a standard date string
         * @param    mixed $holidays,...              Optional series of Excel date serial value (float), PHP date
         *                                            timestamp (integer), PHP DateTime object, or a standard date
         *                                            strings that will be excluded from the working calendar, such
         *                                            as state and federal holidays and floating holidays.
         * @return    integer            Interval between the dates
         */
        public static function NETWORKDAYS($startDate, $endDate) {
            //    Retrieve the mandatory start and end date that are referenced in the function definition
            $startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
            $endDate   = PHPExcel_Calculation_Functions::flattenSingleValue($endDate);
            //    Flush the mandatory start and end date that are referenced in the function definition, and get the optional days
            $dateArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
            array_shift($dateArgs);
            array_shift($dateArgs);
            //    Validate the start and end dates
            if (is_string($startDate = $sDate = self::getDateValue($startDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $startDate = (float)floor($startDate);
            if (is_string($endDate = $eDate = self::getDateValue($endDate))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $endDate = (float)floor($endDate);
            if ($sDate > $eDate) {
                $startDate = $eDate;
                $endDate   = $sDate;
            }
            // Execute function
            $startDoW = 6 - self::DAYOFWEEK($startDate, 2);
            if ($startDoW < 0) {
                $startDoW = 0;
            }
            $endDoW = self::DAYOFWEEK($endDate, 2);
            if ($endDoW >= 6) {
                $endDoW = 0;
            }
            $wholeWeekDays = floor(($endDate - $startDate) / 7) * 5;
            $partWeekDays  = $endDoW + $startDoW;
            if ($partWeekDays > 5) {
                $partWeekDays -= 5;
            }
            //    Test any extra holiday parameters
            $holidayCountedArray = [];
            foreach ($dateArgs as $holidayDate) {
                if (is_string($holidayDate = self::getDateValue($holidayDate))) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
                if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
                    if ((self::DAYOFWEEK($holidayDate, 2) < 6) && (!in_array($holidayDate, $holidayCountedArray))) {
                        --$partWeekDays;
                        $holidayCountedArray[] = $holidayDate;
                    }
                }
            }
            if ($sDate > $eDate) {
                return 0 - ($wholeWeekDays + $partWeekDays);
            }
            return $wholeWeekDays + $partWeekDays;
        }

        /**
         * DAYOFWEEK
         * Returns the day of the week for a specified date. The day is given as an integer
         * ranging from 0 to 7 (dependent on the requested style).
         * Excel Function:
         *        WEEKDAY(dateValue[,style])
         * @param    mixed $dateValue             Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    int   $style                 A number that determines the type of return value
         *                                        1 or omitted    Numbers 1 (Sunday) through 7 (Saturday).
         *                                        2                Numbers 1 (Monday) through 7 (Sunday).
         *                                        3                Numbers 0 (Monday) through 6 (Sunday).
         * @return    int        Day of the week value
         */
        public static function DAYOFWEEK($dateValue = 1, $style = 1) {
            $dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            $style     = PHPExcel_Calculation_Functions::flattenSingleValue($style);
            if (!is_numeric($style)) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif (($style < 1) || ($style > 3)) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            $style = floor($style);
            if ($dateValue === null) {
                $dateValue = 1;
            } elseif (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif ($dateValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
            $DoW           = $PHPDateObject->format('w');
            $firstDay = 1;
            switch ($style) {
                case 1:
                    ++$DoW;
                    break;
                case 2:
                    if ($DoW == 0) {
                        $DoW = 7;
                    }
                    break;
                case 3:
                    if ($DoW == 0) {
                        $DoW = 7;
                    }
                    $firstDay = 0;
                    --$DoW;
                    break;
            }
            if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_EXCEL) {
                //    Test for Excel's 1900 leap year, and introduce the error as required
                if (($PHPDateObject->format('Y') == 1900) && ($PHPDateObject->format('n') <= 2)) {
                    --$DoW;
                    if ($DoW < $firstDay) {
                        $DoW += 7;
                    }
                }
            }
            return (int)$DoW;
        }

        /**
         * WORKDAY
         * Returns the date that is the indicated number of working days before or after a date (the
         * starting date). Working days exclude weekends and any dates identified as holidays.
         * Use WORKDAY to exclude weekends or holidays when you calculate invoice due dates, expected
         * delivery times, or the number of days of work performed.
         * Excel Function:
         *        WORKDAY(startDate,endDays[,holidays[,holiday[,...]]])
         * @access    public
         * @category  Date/Time Functions
         * @param    mixed   $startDate           Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    integer $endDays             The number of nonweekend and nonholiday days before or after
         *                                        startDate. A positive value for days yields a future date; a
         *                                        negative value yields a past date.
         * @param    mixed   $holidays,...        Optional series of Excel date serial value (float), PHP date
         *                                        timestamp (integer), PHP DateTime object, or a standard date
         *                                        strings that will be excluded from the working calendar, such
         *                                        as state and federal holidays and floating holidays.
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                        depending on the value of the ReturnDateType flag
         */
        public static function WORKDAY($startDate, $endDays) {
            //    Retrieve the mandatory start date and days that are referenced in the function definition
            $startDate = PHPExcel_Calculation_Functions::flattenSingleValue($startDate);
            $endDays   = PHPExcel_Calculation_Functions::flattenSingleValue($endDays);
            //    Flush the mandatory start date and days that are referenced in the function definition, and get the optional days
            $dateArgs = PHPExcel_Calculation_Functions::flattenArray(func_get_args());
            array_shift($dateArgs);
            array_shift($dateArgs);
            if ((is_string($startDate = self::getDateValue($startDate))) || (!is_numeric($endDays))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $startDate = (float)floor($startDate);
            $endDays   = (int)floor($endDays);
            //    If endDays is 0, we always return startDate
            if ($endDays == 0) {
                return $startDate;
            }
            $decrementing = ($endDays < 0) ? true : false;
            //    Adjust the start date if it falls over a weekend
            $startDoW = self::DAYOFWEEK($startDate, 3);
            if (self::DAYOFWEEK($startDate, 3) >= 5) {
                $startDate += ($decrementing) ? -$startDoW + 4 : 7 - $startDoW;
                ($decrementing) ? $endDays++ : $endDays--;
            }
            //    Add endDays
            $endDate = (float)$startDate + (intval($endDays / 5) * 7) + ($endDays % 5);
            //    Adjust the calculated end date if it falls over a weekend
            $endDoW = self::DAYOFWEEK($endDate, 3);
            if ($endDoW >= 5) {
                $endDate += ($decrementing) ? -$endDoW + 4 : 7 - $endDoW;
            }
            //    Test any extra holiday parameters
            if (!empty($dateArgs)) {
                $holidayCountedArray = $holidayDates = [];
                foreach ($dateArgs as $holidayDate) {
                    if (($holidayDate !== null) && (trim($holidayDate) > '')) {
                        if (is_string($holidayDate = self::getDateValue($holidayDate))) {
                            return PHPExcel_Calculation_Functions::VALUE();
                        }
                        if (self::DAYOFWEEK($holidayDate, 3) < 5) {
                            $holidayDates[] = $holidayDate;
                        }
                    }
                }
                if ($decrementing) {
                    rsort($holidayDates, SORT_NUMERIC);
                } else {
                    sort($holidayDates, SORT_NUMERIC);
                }
                foreach ($holidayDates as $holidayDate) {
                    if ($decrementing) {
                        if (($holidayDate <= $startDate) && ($holidayDate >= $endDate)) {
                            if (!in_array($holidayDate, $holidayCountedArray)) {
                                --$endDate;
                                $holidayCountedArray[] = $holidayDate;
                            }
                        }
                    } else {
                        if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
                            if (!in_array($holidayDate, $holidayCountedArray)) {
                                ++$endDate;
                                $holidayCountedArray[] = $holidayDate;
                            }
                        }
                    }
                    //    Adjust the calculated end date if it falls over a weekend
                    $endDoW = self::DAYOFWEEK($endDate, 3);
                    if ($endDoW >= 5) {
                        $endDate += ($decrementing) ? -$endDoW + 4 : 7 - $endDoW;
                    }
                }
            }
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    return (float)$endDate;
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    return (integer)PHPExcel_Shared_Date::ExcelToPHP($endDate);
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    return PHPExcel_Shared_Date::ExcelToPHPObject($endDate);
            }
        }

        /**
         * WEEKOFYEAR
         * Returns the week of the year for a specified date.
         * The WEEKNUM function considers the week containing January 1 to be the first week of the year.
         * However, there is a European standard that defines the first week as the one with the majority
         * of days (four or more) falling in the new year. This means that for years in which there are
         * three days or less in the first week of January, the WEEKNUM function returns week numbers
         * that are incorrect according to the European standard.
         * Excel Function:
         *        WEEKNUM(dateValue[,style])
         * @param    mixed   $dateValue           Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    boolean $method              Week begins on Sunday or Monday
         *                                        1 or omitted    Week begins on Sunday.
         *                                        2                Week begins on Monday.
         * @return    int        Week Number
         */
        public static function WEEKOFYEAR($dateValue = 1, $method = 1) {
            $dateValue = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            $method    = PHPExcel_Calculation_Functions::flattenSingleValue($method);
            if (!is_numeric($method)) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif (($method < 1) || ($method > 2)) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            $method = floor($method);
            if ($dateValue === null) {
                $dateValue = 1;
            } elseif (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            } elseif ($dateValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            // Execute function
            $PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
            $dayOfYear     = $PHPDateObject->format('z');
            $dow           = $PHPDateObject->format('w');
            $PHPDateObject->modify('-' . $dayOfYear . ' days');
            $dow             = $PHPDateObject->format('w');
            $daysInFirstWeek = 7 - (($dow + (2 - $method)) % 7);
            $dayOfYear       -= $daysInFirstWeek;
            $weekOfYear      = ceil($dayOfYear / 7) + 1;
            return (int)$weekOfYear;
        }

        /**
         * HOUROFDAY
         * Returns the hour of a time value.
         * The hour is given as an integer, ranging from 0 (12:00 A.M.) to 23 (11:00 P.M.).
         * Excel Function:
         *        HOUR(timeValue)
         * @param    mixed $timeValue         Excel date serial value (float), PHP date timestamp (integer),
         *                                    PHP DateTime object, or a standard time string
         * @return    int        Hour
         */
        public static function HOUROFDAY($timeValue = 0) {
            $timeValue = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
            if (!is_numeric($timeValue)) {
                if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                    $testVal = strtok($timeValue, '/-: ');
                    if (strlen($testVal) < strlen($timeValue)) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                }
                $timeValue = self::getTimeValue($timeValue);
                if (is_string($timeValue)) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
            }
            // Execute function
            if ($timeValue >= 1) {
                $timeValue = fmod($timeValue, 1);
            } elseif ($timeValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            $timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
            return (int)gmdate('G', $timeValue);
        }

        /**
         * getTimeValue
         * @param    string $timeValue
         * @return    mixed    Excel date/time serial value, or string if error
         */
        private static function getTimeValue($timeValue) {
            $saveReturnDateType = PHPExcel_Calculation_Functions::getReturnDateType();
            PHPExcel_Calculation_Functions::setReturnDateType(PHPExcel_Calculation_Functions::RETURNDATE_EXCEL);
            $timeValue = self::TIMEVALUE($timeValue);
            PHPExcel_Calculation_Functions::setReturnDateType($saveReturnDateType);
            return $timeValue;
        }

        /**
         * TIMEVALUE
         * Returns a value that represents a particular time.
         * Use TIMEVALUE to convert a time represented by a text string to an Excel or PHP date/time stamp
         * value.
         * NOTE: When used in a Cell Formula, MS Excel changes the cell format so that it matches the time
         * format of your regional settings. PHPExcel does not change cell formatting in this way.
         * Excel Function:
         *        TIMEVALUE(timeValue)
         * @access    public
         * @category  Date/Time Functions
         * @param    string $timeValue        A text string that represents a time in any one of the Microsoft
         *                                    Excel time formats; for example, "6:45 PM" and "18:45" text strings
         *                                    within quotation marks that represent time.
         *                                    Date information in time_text is ignored.
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                    depending on the value of the ReturnDateType flag
         */
        public static function TIMEVALUE($timeValue) {
            $timeValue = trim(PHPExcel_Calculation_Functions::flattenSingleValue($timeValue), '"');
            $timeValue = str_replace([
                                         '/',
                                         '.'
                                     ], [
                                         '-',
                                         '-'
                                     ], $timeValue
            );
            $PHPDateArray = date_parse($timeValue);
            if (($PHPDateArray !== false) && ($PHPDateArray['error_count'] == 0)) {
                if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_OPENOFFICE) {
                    $excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel($PHPDateArray['year'], $PHPDateArray['month'], $PHPDateArray['day'], $PHPDateArray['hour'], $PHPDateArray['minute'], $PHPDateArray['second']
                    );
                } else {
                    $excelDateValue = PHPExcel_Shared_Date::FormattedPHPToExcel(1900, 1, 1, $PHPDateArray['hour'], $PHPDateArray['minute'], $PHPDateArray['second']) - 1;
                }
                switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                    case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                        return (float)$excelDateValue;
                    case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                        return (integer)$phpDateValue = PHPExcel_Shared_Date::ExcelToPHP($excelDateValue + 25569) - 3600;
                    case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                        return new DateTime('1900-01-01 ' . $PHPDateArray['hour'] . ':' . $PHPDateArray['minute'] . ':' . $PHPDateArray['second']);
                }
            }
            return PHPExcel_Calculation_Functions::VALUE();
        }

        /**
         * MINUTEOFHOUR
         * Returns the minutes of a time value.
         * The minute is given as an integer, ranging from 0 to 59.
         * Excel Function:
         *        MINUTE(timeValue)
         * @param    mixed $timeValue         Excel date serial value (float), PHP date timestamp (integer),
         *                                    PHP DateTime object, or a standard time string
         * @return    int        Minute
         */
        public static function MINUTEOFHOUR($timeValue = 0) {
            $timeValue = $timeTester = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
            if (!is_numeric($timeValue)) {
                if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                    $testVal = strtok($timeValue, '/-: ');
                    if (strlen($testVal) < strlen($timeValue)) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                }
                $timeValue = self::getTimeValue($timeValue);
                if (is_string($timeValue)) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
            }
            // Execute function
            if ($timeValue >= 1) {
                $timeValue = fmod($timeValue, 1);
            } elseif ($timeValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            $timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
            return (int)gmdate('i', $timeValue);
        }

        /**
         * SECONDOFMINUTE
         * Returns the seconds of a time value.
         * The second is given as an integer in the range 0 (zero) to 59.
         * Excel Function:
         *        SECOND(timeValue)
         * @param    mixed $timeValue         Excel date serial value (float), PHP date timestamp (integer),
         *                                    PHP DateTime object, or a standard time string
         * @return    int        Second
         */
        public static function SECONDOFMINUTE($timeValue = 0) {
            $timeValue = PHPExcel_Calculation_Functions::flattenSingleValue($timeValue);
            if (!is_numeric($timeValue)) {
                if (PHPExcel_Calculation_Functions::getCompatibilityMode() == PHPExcel_Calculation_Functions::COMPATIBILITY_GNUMERIC) {
                    $testVal = strtok($timeValue, '/-: ');
                    if (strlen($testVal) < strlen($timeValue)) {
                        return PHPExcel_Calculation_Functions::VALUE();
                    }
                }
                $timeValue = self::getTimeValue($timeValue);
                if (is_string($timeValue)) {
                    return PHPExcel_Calculation_Functions::VALUE();
                }
            }
            // Execute function
            if ($timeValue >= 1) {
                $timeValue = fmod($timeValue, 1);
            } elseif ($timeValue < 0.0) {
                return PHPExcel_Calculation_Functions::NaN();
            }
            $timeValue = PHPExcel_Shared_Date::ExcelToPHP($timeValue);
            return (int)gmdate('s', $timeValue);
        }

        /**
         * EDATE
         * Returns the serial number that represents the date that is the indicated number of months
         * before or after a specified date (the start_date).
         * Use EDATE to calculate maturity dates or due dates that fall on the same day of the month
         * as the date of issue.
         * Excel Function:
         *        EDATE(dateValue,adjustmentMonths)
         * @param    mixed $dateValue             Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    int   $adjustmentMonths      The number of months before or after start_date.
         *                                        A positive value for months yields a future date;
         *                                        a negative value yields a past date.
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                        depending on the value of the ReturnDateType flag
         */
        public static function EDATE($dateValue = 1, $adjustmentMonths = 0) {
            $dateValue        = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            $adjustmentMonths = PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
            if (!is_numeric($adjustmentMonths)) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $adjustmentMonths = floor($adjustmentMonths);
            if (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            // Execute function
            $PHPDateObject = self::adjustDateByMonths($dateValue, $adjustmentMonths);
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    return (float)PHPExcel_Shared_Date::PHPToExcel($PHPDateObject);
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    return (integer)PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::PHPToExcel($PHPDateObject));
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    return $PHPDateObject;
            }
        }

        private static function adjustDateByMonths($dateValue = 0, $adjustmentMonths = 0) {
            // Execute function
            $PHPDateObject = PHPExcel_Shared_Date::ExcelToPHPObject($dateValue);
            $oMonth        = (int)$PHPDateObject->format('m');
            $oYear         = (int)$PHPDateObject->format('Y');
            $adjustmentMonthsString = (string)$adjustmentMonths;
            if ($adjustmentMonths > 0) {
                $adjustmentMonthsString = '+' . $adjustmentMonths;
            }
            if ($adjustmentMonths != 0) {
                $PHPDateObject->modify($adjustmentMonthsString . ' months');
            }
            $nMonth = (int)$PHPDateObject->format('m');
            $nYear  = (int)$PHPDateObject->format('Y');
            $monthDiff = ($nMonth - $oMonth) + (($nYear - $oYear) * 12);
            if ($monthDiff != $adjustmentMonths) {
                $adjustDays       = (int)$PHPDateObject->format('d');
                $adjustDaysString = '-' . $adjustDays . ' days';
                $PHPDateObject->modify($adjustDaysString);
            }
            return $PHPDateObject;
        }

        /**
         * EOMONTH
         * Returns the date value for the last day of the month that is the indicated number of months
         * before or after start_date.
         * Use EOMONTH to calculate maturity dates or due dates that fall on the last day of the month.
         * Excel Function:
         *        EOMONTH(dateValue,adjustmentMonths)
         * @param    mixed $dateValue             Excel date serial value (float), PHP date timestamp (integer),
         *                                        PHP DateTime object, or a standard date string
         * @param    int   $adjustmentMonths      The number of months before or after start_date.
         *                                        A positive value for months yields a future date;
         *                                        a negative value yields a past date.
         * @return    mixed    Excel date/time serial value, PHP date/time serial value or PHP date/time object,
         *                                        depending on the value of the ReturnDateType flag
         */
        public static function EOMONTH($dateValue = 1, $adjustmentMonths = 0) {
            $dateValue        = PHPExcel_Calculation_Functions::flattenSingleValue($dateValue);
            $adjustmentMonths = PHPExcel_Calculation_Functions::flattenSingleValue($adjustmentMonths);
            if (!is_numeric($adjustmentMonths)) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            $adjustmentMonths = floor($adjustmentMonths);
            if (is_string($dateValue = self::getDateValue($dateValue))) {
                return PHPExcel_Calculation_Functions::VALUE();
            }
            // Execute function
            $PHPDateObject    = self::adjustDateByMonths($dateValue, $adjustmentMonths + 1);
            $adjustDays       = (int)$PHPDateObject->format('d');
            $adjustDaysString = '-' . $adjustDays . ' days';
            $PHPDateObject->modify($adjustDaysString);
            switch (PHPExcel_Calculation_Functions::getReturnDateType()) {
                case PHPExcel_Calculation_Functions::RETURNDATE_EXCEL:
                    return (float)PHPExcel_Shared_Date::PHPToExcel($PHPDateObject);
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_NUMERIC:
                    return (integer)PHPExcel_Shared_Date::ExcelToPHP(PHPExcel_Shared_Date::PHPToExcel($PHPDateObject));
                case PHPExcel_Calculation_Functions::RETURNDATE_PHP_OBJECT:
                    return $PHPDateObject;
            }
        }
    }
